/***********************************************************************
 * Module:  JClientLibrary.cpp
 * Author:  johnneyshi
 * Modified: 2012��12��14�� 16:25:35
 * Purpose: Implementation of the class JClientLibrary
 ***********************************************************************/

#include "JClientLibrary.h"
#include "JWorkingCopies.h"

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::SubmitUpdateCopy(char* _copyDirPath)
// Purpose:    Implementation of JClientLibrary::SubmitUpdateCopy()
// Parameters:
// - _copyDirPath
// Return:     JUpdateConflict
////////////////////////////////////////////////////////////////////////

JUpdateConflict JClientLibrary::SubmitUpdateCopy(char* _copyDirPath)
{
   // TODO : implement
	return *(new JUpdateConflict);
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::ReadConfig(char* _configFileName)
// Purpose:    Implementation of JClientLibrary::ReadConfig()
// Parameters:
// - _configFileName
// Return:     void
////////////////////////////////////////////////////////////////////////

void JClientLibrary::ReadConfig(char* _configFileName)
{
   // TODO : implement
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::SerializeFiles(std::iostream _strea, std::vector<JFile> _files)
// Purpose:    Implementation of JClientLibrary::SerializeFiles()
// Parameters:
// - _strea
// - _files
// Return:     int
////////////////////////////////////////////////////////////////////////

int JClientLibrary::SerializeFiles(std::iostream _strea, std::vector<JFile> _files)
{
   // TODO : implement
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::CommitCopy(char* _copyDirPath)
// Purpose:    Implementation of JClientLibrary::CommitCopy()
// Parameters:
// - _copyDirPath
// Return:     JCommitConflict
////////////////////////////////////////////////////////////////////////

JCommitConflict JClientLibrary::CommitCopy(char* _copyDirPath)
{
   // TODO : implement
	return *(new JCommitConflict);
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::ReSerializeCommitConflicts(std::iostream _strea, std::vector<JCommitConflict> _commitConflicts)
// Purpose:    Implementation of JClientLibrary::ReSerializeCommitConflicts()
// Parameters:
// - _strea
// - _commitConflicts
// Return:     void
////////////////////////////////////////////////////////////////////////

void JClientLibrary::ReSerializeCommitConflicts(std::iostream _strea, std::vector<JCommitConflict> _commitConflicts)
{
   // TODO : implement
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::CollectFiles(char* _copyDirPath, std::vector<JFile> _files, JCollectFileType _collectType)
// Purpose:    Implementation of JClientLibrary::CollectFiles()
// Parameters:
// - _copyDirPath
// - _files
// - _collectType
// Return:     void
////////////////////////////////////////////////////////////////////////

void JClientLibrary::CollectFiles(char* _copyDirPath, std::vector<JFile> _files, JCollectFileType _collectType)
{
   // TODO : implement
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::ReSerializeFilesAndUpdateConflicts(std::iostream _strea, std::vector<JFile> _files, std::vector<JUpdateConflict> _updateConflicts)
// Purpose:    Implementation of JClientLibrary::ReSerializeFilesAndUpdateConflicts()
// Parameters:
// - _strea
// - _files
// - _updateConflicts
// Return:     int
////////////////////////////////////////////////////////////////////////

int JClientLibrary::ReSerializeFilesAndUpdateConflicts(std::iostream _strea, std::vector<JFile> _files, std::vector<JUpdateConflict> _updateConflicts)
{
   // TODO : implement
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::BasicOperAddFile(char* _fileName)
// Purpose:    Implementation of JClientLibrary::BasicOperAddFile()
// Parameters:
// - _fileName
// Return:     JOperateFileResult
////////////////////////////////////////////////////////////////////////

JOperateFileResult JClientLibrary::BasicOperAddFile(char* _fileName)
{
	JWorkingCopies copies;
	return copies.AddFile(_fileName,true);
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::UpdateCopyBak(std::vector<JFile> _files, std::vector<JUpdateConflict> _updateConflicts)
// Purpose:    Implementation of JClientLibrary::UpdateCopyBak()
// Parameters:
// - _files
// - _updateConflicts
// Return:     void
////////////////////////////////////////////////////////////////////////

void JClientLibrary::UpdateCopyBak(std::vector<JFile> _files, std::vector<JUpdateConflict> _updateConflicts)
{
   // TODO : implement
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::UpdateCopy(std::vector<JFile> _files, std::vector<JUpdateConflict> _updateConflicts)
// Purpose:    Implementation of JClientLibrary::UpdateCopy()
// Parameters:
// - _files
// - _updateConflicts
// Return:     void
////////////////////////////////////////////////////////////////////////

void JClientLibrary::UpdateCopy(std::vector<JFile> _files, std::vector<JUpdateConflict> _updateConflicts)
{
   // TODO : implement
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::SaveUpdateConflicts(std::vector<JUpdateConflict> _updateConflicts)
// Purpose:    Implementation of JClientLibrary::SaveUpdateConflicts()
// Parameters:
// - _updateConflicts
// Return:     void
////////////////////////////////////////////////////////////////////////

void JClientLibrary::SaveUpdateConflicts(std::vector<JUpdateConflict> _updateConflicts)
{
   // TODO : implement
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::UpdateCopy(std::vector<JFile> _files, std::vector<JCommitConflict> _commitConflicts)
// Purpose:    Implementation of JClientLibrary::UpdateCopy()
// Parameters:
// - _files
// - _commitConflicts
// Return:     void
////////////////////////////////////////////////////////////////////////

void JClientLibrary::UpdateCopy(std::vector<JFile> _files, std::vector<JCommitConflict> _commitConflicts)
{
   // TODO : implement
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::UpdateCopyBak(std::vector<JFile> _files, std::vector<JCommitConflict> _commitConflicts)
// Purpose:    Implementation of JClientLibrary::UpdateCopyBak()
// Parameters:
// - _files
// - _commitConflicts
// Return:     void
////////////////////////////////////////////////////////////////////////

void JClientLibrary::UpdateCopyBak(std::vector<JFile> _files, std::vector<JCommitConflict> _commitConflicts)
{
   // TODO : implement
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::ReportConflicts(std::vector<JUpdateConflict> _updateConflicts)
// Purpose:    Implementation of JClientLibrary::ReportConflicts()
// Parameters:
// - _updateConflicts
// Return:     void
////////////////////////////////////////////////////////////////////////

void JClientLibrary::ReportConflicts(std::vector<JUpdateConflict> _updateConflicts)
{
   // TODO : implement
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::ReportConflicts(std::vector<JCommitConflict> _commitConflicts)
// Purpose:    Implementation of JClientLibrary::ReportConflicts()
// Parameters:
// - _commitConflicts
// Return:     void
////////////////////////////////////////////////////////////////////////

void JClientLibrary::ReportConflicts(std::vector<JCommitConflict> _commitConflicts)
{
   // TODO : implement
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::BasicOperUpdateCopy(std::vector<JFile> _files, JFileOperationType _fileOperationType)
// Purpose:    Implementation of JClientLibrary::BasicOperUpdateCopy()
// Parameters:
// - _files
// - _fileOperationType
// Return:     JOperateFileResult
////////////////////////////////////////////////////////////////////////

JOperateFileResult JClientLibrary::BasicOperUpdateCopy(std::vector<JFile> _files, JFileOperationType _fileOperationType)
{
   // TODO : implement
	return *(new JOperateFileResult);
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::ReadFile(char* _fileName, JFile _file)
// Purpose:    Implementation of JClientLibrary::ReadFile()
// Parameters:
// - _fileName
// - _file
// Return:     void
////////////////////////////////////////////////////////////////////////

void JClientLibrary::ReadFile(char* _fileName, JFile _file)
{
   // TODO : implement
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::BasicOperDeleteFile(char* _fileName)
// Purpose:    Implementation of JClientLibrary::BasicOperDeleteFile()
// Parameters:
// - _fileName
// Return:     JOperateFileResult
////////////////////////////////////////////////////////////////////////

JOperateFileResult JClientLibrary::BasicOperDeleteFile(char* _fileName)
{
	JWorkingCopies copies;
	return copies.DeleteFile(_fileName);
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::BasicOperCopyFile(char* _fileName, char* _newFileName)
// Purpose:    Implementation of JClientLibrary::BasicOperCopyFile()
// Parameters:
// - _fileName
// - _newFileName
// Return:     JOperateFileResult
////////////////////////////////////////////////////////////////////////

JOperateFileResult JClientLibrary::BasicOperCopyFile(char* _fileName, char* _newFileName)
{
   // TODO : implement
	return *(new JOperateFileResult);
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::BasicOperMoveFile(char* _fileName, char* _newFileName)
// Purpose:    Implementation of JClientLibrary::BasicOperMoveFile()
// Parameters:
// - _fileName
// - _newFileName
// Return:     JOperateFileResult
////////////////////////////////////////////////////////////////////////

JOperateFileResult JClientLibrary::BasicOperMoveFile(char* _fileName, char* _newFileName)
{
	JWorkingCopies copies;
	return copies.ModifyFile(_fileName,_newFileName);
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::BasicOperUndoFile(char* _fileName)
// Purpose:    Implementation of JClientLibrary::BasicOperUndoFile()
// Parameters:
// - _fileName
// Return:     int
////////////////////////////////////////////////////////////////////////

int JClientLibrary::BasicOperUndoFile(char* _fileName)
{
   // TODO : implement
	return 0;
}

////////////////////////////////////////////////////////////////////////
// Name:       JClientLibrary::BasicOperCheckFile(char* _fileName)
// Purpose:    Implementation of JClientLibrary::BasicOperCheckFile()
// Parameters:
// - _fileName
// Return:     int
////////////////////////////////////////////////////////////////////////

JOperateFileResult JClientLibrary::BasicOperCheckFile(char* _fileName)
{
	JWorkingCopies copies;
	return copies.FileStatus(_fileName);
}

std::string JClientLibrary::CreateWorkingCopies(std::string rootUrl,std::string author,std::string password,std::string _fullPath )
{
	JWorkingCopies copies;
	return copies.CreateWorkingCopies(rootUrl,author,password,_fullPath);
}


std::vector<JUpdateConflict> JClientLibrary::Update(std::vector<JFile> _files)
{
    
}

std::vector<JCommitConflict> JClientLibrary::Commit(std::string _dirPath)
{
    
}